package com.example.service;

import com.bob.auth.dto.request.EmployeeInsertRequest;
import com.example.dto.EmployeeQueryRequest;
import com.example.dto.PageResult;
import com.example.entity.Employee;
import com.example.mapper.EmployeeMapper;
import com.fasterxml.jackson.databind.util.BeanUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;
import java.util.UUID;

/**
 * 员工服务
 */
@Slf4j
@Service
public class EmployeeService {
    
    @Resource
    private EmployeeMapper employeeMapper;
    
    /**
     * 简单批量插入员工数据（忽略重复，继续插入其他）
     * 用于简化版导入，不进行复杂验证
     */
    @Transactional(rollbackFor = Exception.class)
    public void batchInsertSimple(List<EmployeeInsertRequest> employees) {
        log.info("开始批量插入员工数据，共 {} 条", employees.size());
        
        int successCount = 0;
        int skipCount = 0;
        
        for (EmployeeInsertRequest emp : employees) {
            try {
                // 检查是否已存在
                Employee existing = employeeMapper.selectByUserCode(emp.getUserCode());
                if (existing != null) {
                    log.debug("用户编码已存在，跳过：{}", emp.getUserCode());
                    skipCount++;
                    continue;
                }
                
                // 插入数据
                employeeMapper.insert(emp);
                successCount++;
                
            } catch (Exception e) {
                log.warn("插入员工数据失败，跳过：{} - {}", emp.getUserCode(), e.getMessage());
                skipCount++;
            }
        }
        
        log.info("批量插入完成：成功 {} 条，跳过 {} 条", successCount, skipCount);
    }
    
    /**
     * 分页查询员工列表
     * 
     * @param query 查询条件
     * @return 分页结果
     */
    public PageResult<Employee> queryByPage(EmployeeQueryRequest query) {
        log.info("分页查询员工，条件：{}", query);
        
        // 参数校验
        if (query.getPageNum() == null || query.getPageNum() < 1) {
            query.setPageNum(1);
        }
        if (query.getPageSize() == null || query.getPageSize() < 1) {
            query.setPageSize(10);
        }
        if (query.getPageSize() > 100) {
            query.setPageSize(100); // 限制最大每页100条
        }
        
        // 查询总数
        Long total = employeeMapper.countByCondition(query);
        
        // 如果没有数据，直接返回空结果
        if (total == 0) {
            log.info("查询结果为空");
            return PageResult.empty(query.getPageNum(), query.getPageSize());
        }
        
        // 查询数据列表
        List<Employee> records = employeeMapper.selectByPage(query);
        
        log.info("查询完成，总数：{}，当前页：{}，每页：{}，返回：{} 条", 
                total, query.getPageNum(), query.getPageSize(), records.size());
        
        return new PageResult<>(records, total, query.getPageNum(), query.getPageSize());
    }
    
    /**
     * 智能查询员工列表（自动识别userCode或fullName）
     * 
     * @param query 查询条件
     * @return 分页结果
     */
    public PageResult<Employee> queryByPageWithSmartSearch(EmployeeQueryRequest query) {
        log.info("智能查询员工，原始查询条件：{}", query);
        
        // 解析 userCodeOrFullName 字段
        parseUserCodeOrFullName(query);
        
        // 调用标准分页查询方法
        return queryByPage(query);
    }
    
    /**
     * 解析 userCodeOrFullName 字段，自动设置到对应的查询字段
     * 判断规则：纯数字视为 userCode，包含中文视为 fullName，其他情况默认按 userCode 处理
     * 
     * @param query 查询请求对象
     */
    private void parseUserCodeOrFullName(EmployeeQueryRequest query) {
        String input = query.getUserCodeOrFullName();
        
        // 如果输入为空，直接返回
        if (input == null || input.trim().isEmpty()) {
            return;
        }
        
        input = input.trim();
        
        // 判断是否包含中文字符
        if (containsChinese(input)) {
            // 包含中文，按姓名查询
            query.setFullName(input);
            log.info("识别为姓名查询：{}", input);
        } else if (isNumeric(input)) {
            // 纯数字，按用户编码查询
            query.setUserCode(input);
            log.info("识别为用户编码查询：{}", input);
        } else {
            // 其他情况（如字母、特殊字符等），默认按用户编码模糊查询
            query.setUserCode(input);
            log.info("默认按用户编码查询：{}", input);
        }
    }
    
    /**
     * 判断字符串是否包含中文字符
     * 
     * @param str 待检查的字符串
     * @return 是否包含中文
     */
    private boolean containsChinese(String str) {
        if (str == null || str.isEmpty()) {
            return false;
        }
        
        // 中文字符的 Unicode 范围：\u4e00-\u9fa5
        for (char c : str.toCharArray()) {
            if (c >= 0x4e00 && c <= 0x9fa5) {
                return true;
            }
        }
        return false;
    }
    
    /**
     * 判断字符串是否为纯数字
     * 
     * @param str 待检查的字符串
     * @return 是否为纯数字
     */
    private boolean isNumeric(String str) {
        if (str == null || str.isEmpty()) {
            return false;
        }
        
        // 使用正则表达式判断是否为纯数字
        return str.matches("\\d+");
    }
    
}
